const express = require('express')
const fs = require('fs')
let path = require('path')
const response = require('../../utils/response')
const Task = require('../../models/task')

const archiver = require('archiver');
const loop = require('../../utils/loop')

// 创建一个空的压缩包
const zlib = require('zlib')
const gzib = zlib.createGzip()
const router = express.Router()

// 生成日期
function add0(m) {
    return m < 10 ? '0' + m : m
}
var time = new Date();
var y = time.getFullYear();
var m = time.getMonth() + 1;
var d = time.getDate();
var h = time.getHours();
var mm = time.getMinutes();
var s = time.getSeconds();
m = add0(m)
d = add0(d)
h = add0(h)
mm = add0(mm)
s = add0(s)


// 测试
router.get('/ceshi', async (req, res) => {
    res.download('uploads/export/2021-11-21-16-06-17-9462/')
})

// 顶级任务导出
router.get('/downloadChildren/:taskId', async (req, res) => {
    let taskId = req.params.taskId
    let task = await Task.find({
        _id: taskId
    }).lean()
    if (!task) {
        response(res, 404, '没有该任务')
    }
    await loop.deanTask(task)

    // 日期/随机数
    var ran = Math.ceil(Math.random() * 10000);
    var exportDate = y + '-' + m + '-' + d + '-' + h + '-' + mm + '-' + s + '-' + ran

    // 创建文件接收zip
    fs.mkdirSync(`uploads/export/${exportDate}`, (err) => {
        console.log(err);
    })

    // 创建文件输出流
    let output = await fs.createWriteStream(`uploads/export/${exportDate}/${task[0].taskname}.zip`)
    let archive = await archiver('zip', {
        zlib: {
            level: 9
        } // 设置压缩级别
    })

    // 文件输出流结束
    output.on('close', function () {
        console.log(`总共 ${archive.pointer()} 字节`)
        console.log('archiver完成文件的归档，文件输出流描述符已关闭')
    })

    // 数据源是否耗尽
    output.on('end', function () {
        console.log('数据源已耗尽')
    })

    // 存档警告
    archive.on('warning', function (err) {
        if (err.code === 'ENOENT') {
            console.warn('stat故障和其他非阻塞错误')
        } else {
            throw err
        }
    })

    // 存档出错
    archive.on('error', function (err) {
        throw err
    })

    // 通过管道方法将输出流存档到文件
    archive.pipe(output)
    var isFiles = 0
    async function file(task) {
        // 循环附加文件
        if (task.length > 0) {
            for (val of task[0].fileAddress) {
                // console.log(val);
                let files = val.files
                for (i in files) {
                    let filename = files[i].path + '-' + files[i].originalname
                    // 从流中附加文件
                    let index = `${filename}`
                    if (index) {
                        isFiles++
                    }
                    try {
                        fs.statSync(index)
                        console.log(index);
                        archive.append(fs.createReadStream(index), {
                            name: `${files[i].originalname}`
                        })
                    } catch (error) {
                        let index = './uploads/404/404.txt'
                        archive.append(fs.createReadStream(index), {
                            name: `404文件丢失(${files[i].originalname})`
                        })
                    }
                    // 从子目录追加文件并将其命名为“新子dir”在存档中
                    archive.directory('static/', 'static')
                }
            }
            if (task[0].children) {
                for (let childrenTask of task[0].children) {
                    // console.log(childrenTask);
                    await file(childrenTask)
                }
            }
        } else {
            if(task.fileAddress.length > 0) {
                for (val of task.fileAddress) {
                    // console.log(val);
                    let files = val.files
                    for (i in files) {
                        let filename = files[i].path + '-' + files[i].originalname
                        // 从流中附加文件
                        let index = `${filename}`
                        if (index) {
                            isFiles++
                        }
                        try {
                            fs.statSync(index)
                            console.log(index);
                            archive.append(fs.createReadStream(index), {
                                name: `${files[i].originalname}`
                            })
                        } catch (error) {
                            let index = './uploads/404/404.txt'
                            archive.append(fs.createReadStream(index), {
                                name: `404文件丢失(${files[i].originalname})`
                            })
                        }
                        // 从子目录追加文件并将其命名为“新子dir”在存档中
                        archive.directory('static/', 'static')
                    }
                }
            }
            if (task.children) {
                for (let childrenTask of task.children) {
                    // console.log(childrenTask);
                    await file(childrenTask)
                }
            }
        }
    }

    await file(task)

    // 完成归档
    await archive.finalize()
    setTimeout(function () {
        res.download(`uploads/export/${exportDate}/${task[0].taskname}.zip`)
    }, 1000)
    // if (isFiles > 0) {
    //     await archive.finalize()
    //     setTimeout(function () {
    //         res.download(`uploads/export/${exportDate}/${task[0].taskname}.zip`)
    //     }, 1000)
    // } else {
    //     response(res, 404, `${task[0].taskname}任务没有文件~~~`)
    // }

})

// 单任务导出
router.get('/download/:taskId', async (req, res) => {
    let taskId = req.params.taskId
    let task = await Task.findById(taskId)
    if (!task) {
        response(res, 404, '没有该任务')
    }

    // 日期/随机数
    var ran = Math.ceil(Math.random() * 10000);
    var exportDate = y + '-' + m + '-' + d + '-' + h + '-' + mm + '-' + s + '-' + ran

    // 创建文件接收zip
    fs.mkdirSync(`uploads/export/${exportDate}`, (err) => {
        console.log(err);
    })

    // 创建文件输出流
    let output = await fs.createWriteStream(`uploads/export/${exportDate}/${task.taskname}.zip`)
    let archive = await archiver('zip', {
        zlib: {
            level: 9
        } // 设置压缩级别
    })

    // 文件输出流结束
    output.on('close', function () {
        console.log(`总共 ${archive.pointer()} 字节`)
        console.log('archiver完成文件的归档，文件输出流描述符已关闭')
    })

    // 数据源是否耗尽
    output.on('end', function () {
        console.log('数据源已耗尽')
    })

    // 存档警告
    archive.on('warning', function (err) {
        if (err.code === 'ENOENT') {
            console.warn('stat故障和其他非阻塞错误')
        } else {
            throw err
        }
    })

    // 存档出错
    archive.on('error', function (err) {
        throw err
    })

    // 通过管道方法将输出流存档到文件
    archive.pipe(output)

    // 循环附加文件
    var isFiles = 0

    for (val of task.fileAddress) {
        let files = val.files
        for (i in files) {
            let filename = files[i].path + '-' + files[i].originalname
            // console.log(files);

            // 从流中附加文件
            let index = `${filename}`
            if (index) {
                isFiles++
            }
            try {
                fs.statSync(index)
                console.log(index);
                archive.append(fs.createReadStream(index), {
                    name: `${files[i].originalname}`
                })
            } catch (error) {
                let index = './uploads/404/404.txt'
                archive.append(fs.createReadStream(index), {
                    name: `404文件丢失(${files[i].originalname})`
                })
            }
            // 从子目录追加文件并将其命名为“新子dir”在存档中
            archive.directory('static/', 'static')
        }
    }

    // 完成归档
    if (isFiles > 0) {
        await archive.finalize()
        setTimeout(function () {
            res.download(`uploads/export/${exportDate}/${task.taskname}.zip`)
        }, 1000)
    } else {
        response(res, 404, `${task.taskname}任务没有文件~~~`)
    }
})

// 分类导出
// router.get('/downloadClassification', async (req, res) => {
//     let classificationNum = req.query.classification
//     let task = await Task.find()

//     if (classificationNum == 0) {
//         var classificationName = '教材'
//     } else if (classificationNum == 1) {
//         var classificationName = '线上培训'
//     } else if (classificationNum == 2) {
//         var classificationName = '线下培训'
//     } else if (classificationNum == 3) {
//         var classificationName = '校企技术服务'
//     } else if (classificationNum == 4) {
//         var classificationName = '精品课程'
//     } else if (classificationNum == 5) {
//         var classificationName = '指导学生比赛获奖'
//     }

//     // 日期/随机数
//     var ran = Math.ceil(Math.random() * 10000);
//     var exportDate = y + '-' + m + '-' + d + '-' + h + '-' + mm + '-' + s + '-' + ran

//     // 创建文件接收数据
//     fs.mkdir(`uploads/export/${exportDate}`, (err) => {
//         console.log(err);
//     })

//     //创建文件输出流
//     let output = fs.createWriteStream(`uploads/export/${exportDate}/${classificationName}.zip`)
//     let archive = archiver('zip', {
//         zlib: { level: 9 } // 设置压缩级别
//     })

//     // 文件输出流结束
//     output.on('close', function () {
//         console.log(`总共 ${archive.pointer()} 字节`)
//         console.log('archiver完成文件的归档，文件输出流描述符已关闭')
//     })

//     // 数据源是否耗尽
//     output.on('end', function () {
//         console.log('数据源已耗尽')
//     })

//     // 存档警告
//     archive.on('warning', function (err) {
//         if (err.code === 'ENOENT') {
//             console.warn('stat故障和其他非阻塞错误')
//         } else {
//             throw err
//         }
//     })

//     // 存档出错
//     archive.on('error', function (err) {
//         throw err
//     })

//     // 通过管道方法将输出流存档到文件
//     archive.pipe(output)

//     // 循环附加文件
//     var isFiles = 0
//     for (fileAddressVal of task) {
//         var fileAddress = fileAddressVal.fileAddress
//         if (fileAddress.length != 0 && fileAddress[0].classification == classificationNum) {
//             for (filesVal of fileAddress) {
//                 var files = filesVal.files
//                 for (i in files) {
//                     let filename = files[i].path + '-' + files[i].originalname

//                     // 从流中附加文件
//                     let index = `${filename}`
//                     // 判断是否有文件
//                     if (index) {
//                         isFiles++
//                     }
//                     try {
//                         fs.statSync(index)
//                         console.log(index);
//                         archive.append(fs.createReadStream(index), { name: `${files[i].originalname}` })
//                     } catch (error) {
//                         let index = 'uploads\\404\\404.txt'
//                         archive.append(fs.createReadStream(index), { name: `404文件丢失(${files[i].originalname})` })
//                     }
//                     // 从子目录追加文件并将其命名为“新子dir”在存档中
//                     archive.directory('static/', 'static')
//                 }
//             }
//         }
//     }
//     // 完成归档
//     if (isFiles > 0) {
//         await archive.finalize()
//         setTimeout(function () {
//             res.download(`uploads/export/${exportDate}/${classificationName}.zip`)
//         }, 1000)

//     } else {
//         response(res, 404, `没有${classificationName}文件~~~`)
//     }

// })

module.exports = router